/*
 * Indiana University Community Grid Computing Lab Software License,Version 1.1
 *
 * Copyright (c) 2002 Community Grid Computing Lab, Indiana University.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *      "This product includes software developed by the Indiana University
 *       Community Grid Computing Lab (http://www.communitygrids.iu.edu/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Indiana Univeristy","Indiana Univeristy Pervasive Techonology
 *    Labs" and  "Indiana Univeristy Community Grid Computing Lab" must not be
 *    used to endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    http://www.communitygrids.iu.edu/.
 *
 * 5. Products derived from this software may not use "Indiana
 *    University" name nor may "Indiana University" appear in their name,
 *    without prior written permission of the Indiana University.
 *
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * INDIANA UNIVERSITY OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package cgl.sensorgrid.sopac.gps.filters;

/**
 * <p>Title: Sensor Grid</p>
 *
 * <p>Copyright: Copyright (c) 2005</p>
 *
 * <p>Company: CGL</p>
 *
 * @author Galip Aydin
 * @version 1.0
 */

import java.util.*;

import cgl.narada.event.*;
import cgl.sensorgrid.filters.*;
import cgl.sensorgrid.sopac.gps.threadpool.*;


class SingleStationFilter implements Runnable {

    static private int count = 0;
    private SingleStation ss;

    /**
     *
     * @param done
     */
    SingleStationFilter(SingleStation ss_) {
        this.ss = ss_;
    }

    private Object syncObj1 = new Object();
    private List eventList = Collections.synchronizedList(new LinkedList());
    public void addEvent(NBEvent event) {
        synchronized (syncObj1) {
            eventList.add(event);
            if (eventList.size() == 1) {
                syncObj1.notify();
            }
        }
    }

    /**
     *
     */
    public void run() {
        boolean running = true;
        try {
            while (running) {
                synchronized (syncObj1) {
                    if (eventList.size() == 0) {
                        syncObj1.wait();
                    }
                    byte[] data2 = ((NBEvent) eventList.remove(0)).
                                   getContentPayload();
                    if (data2 != null && data2.length > 0) {
                        extractStation(data2);
                    }
                }
            }
            return;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     *
     * @param data byte[]
     */
    public void extractStation(byte[] data) {
        try {
            String msg = new String(data);
            StringTokenizer st = new StringTokenizer(msg, "\n");
            boolean chck = true;
            while (st.hasMoreTokens() && chck) {
                String token = st.nextToken();
                //if (token != null && token.startsWith(ss.getStationName()) && chck) {
                if (token != null && (token.indexOf(ss.getStationName()) > -1) &&
                    chck) {
                    chck = false;
                    if (count >= 1000) {
                        count = 0;
                        System.out.println("SingleStation 1000 records\n");
                    } else {
                        // System.out.print(count++ +" ");
                    }
//                    ss.publishData((token + "\nEOF\n").getBytes());
                    ss.publishData((token + "\n").getBytes());
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}


/**
 *
 * <p>Title: Sensor Grid</p>
 *
 * <p>Description: A Grid Architecture for combining GIS services with
 * Scientific Visualization and Simulation codes</p>
 *
 * <p>Copyright: Copyright (c) 2005</p>
 *
 * <p>Company: CGL</p>
 *
 * @author Galip Aydin
 * @version 1.0
 */
public class SingleStation extends Filter {
    private static ThreadPool pool = new ThreadPool(10);
    private String stationName;
    static private int count = 0;
    private SingleStationFilter ssf;

    /**
     *
     * @param args String[]
     * @param filterSpecificArgs String[]
     */
    public SingleStation(String[] args, String[] filterSpecificArgs) {
        if (filterSpecificArgs == null || filterSpecificArgs.length == 0) {
            System.err.println(
                    "Incorrect number of arguments in SingleStation::Constructor...");
            System.exit(0);
        } else {
            System.out.println("in SingleStation::init()");
            this.initialize(args);
            if (filterSpecificArgs[0] != null &&
                filterSpecificArgs[0].length() > 0) {
                this.stationName = filterSpecificArgs[0];
            }
            ssf = new SingleStationFilter(this);
            ssf.run();
        }
    }

    /**
     *
     * @param nbEvent NBEvent
     */
    public void onEvent(NBEvent nbEvent) {
        if (nbEvent != null && nbEvent.getContentPayload() != null) {
            if (ssf != null) {
                ssf.addEvent(nbEvent);
            }
        }
    }

    /**
     *
     * @return String
     */
    public String getStationName() {
        return stationName;
    }

    /**
     *
     *
     *
     */
    public static void main(String args[]) {
        if (args.length < 6) {
            System.out.println("Usage: java cgl.sensorgrid.sopac.gps.filters.SingleStation "+
                               "commType nbHost nbPort subTopic pubTopic siteName");
            System.exit(0);
        }
        String commType = args[0];
        String nbHost = args[1];
        String nbPort = args[2];
        String subTopic = args[3];
        String pubTopic = args[4];
        String siteName = args[5];

        String[] argsa = {commType,
                         nbHost,
                         nbPort,
                         subTopic,
                         pubTopic};

//        String siteName = "RAAP";
//    //String[] sites = {"LOWS", "MASW", "MIDA", "MNMC", "CARH", "RNCH", "TBLP","HOGS", "POMM"};
//        String[] argsa = {"niotcp",
//                         "gf2.ucs.indiana.edu",
//                         "3045",
//                         "/SOPAC/GPS/CRTN_01/POS",
//                         "/SOPAC/GPS/CRTN_01/POS/" + siteName};
////
        String[] argsb = {siteName};
        SingleStation test = new SingleStation(argsa, argsb);
    }
}
